package cn.antblog.leetcode;

import java.util.HashMap;

/**
 * @author YangJingyi
 * @date 2021-11-19 16:11
 */
public class ArrayReverse {


    public static void main(String[] args) {
        String [] ages =  new String[] {"1","98","66","11"};
        //arrayReverse2(ages);

        //reverse(123);
        //twoSum(new int[]{3,7,11,2},9);
        twoSum2(new int[]{3,7,11,2},9);
    }



    //数组倒叙
    public static void arrayReverse1(String [] ages ){
        System.out.println(ages.toString());

        String [] agesR = new String[3];
        int j = 0;
        for (int i = ages.length -1; i >= 0 ; i--) {
            String age = ages[i];
            agesR[j] = age;
            j++;
        }
        for (String age : agesR) {
            System.out.println(age);
        }
    }

    public static void arrayReverse2(String [] ages ){
        System.out.println(ages.toString());

       int left = 0;
       int right = ages.length -1 ;

       while (left<= right){
           String tmp = ages[right];
           ages[right] = ages[left];
           ages[left] = tmp;
           left++;
           right--;
       }
        for (String age : ages) {
            System.out.println(age);
        }
    }

    public static int intReverse1(int  age ){
        if(age == 0){
            return 0;
        }
        int i1 = 0;
        int i2 = 0;
        i1 =  age % 10;
        int i3 = age / 100;

        String i =  i1+""+i3;
        System.out.println(i);
        return Integer.valueOf(i);
    }

//    public static int reverse(int x) {
//        int n = 0;
//        while (x != 0) {
//            n = n*10 + x%10;
//            x = x/10;
//        }
//        return n==n? (int)n:0;
//    }

    public static int reverse(int x) {
        int n = 0;
        while (x != 0) {
            if (n < Integer.MIN_VALUE || n > Integer.MAX_VALUE) {
                return 0;
            }else{
                n = n*10 + x%10;
                x = x/10;
            }
        }
        int r = n==n? (int)n:0;
        return r;
    }

    //给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出 和为目标值 target  的那 两个 整数，并返回它们的数组下标。
    //你可以假设每种输入只会对应一个答案。但是，数组中同一个元素在答案里不能重复出现。
    //你可以按任意顺序返回答案。
    //示例 1：
    //输入：nums = [2,7,11,15], target = 9
    //输出：[0,1]
    //解释：因为 nums[0] + nums[1] == 9 ，返回 [0, 1] 。
    //示例 2：
    //输入：nums = [3,2,4], target = 6
    //输出：[1,2]
    //示例 3：
    //输入：nums = [3,3], target = 6
    //输出：[0,1]
    //提示：
    //2 <= nums.length <= 104
    //-109 <= nums[i] <= 109
    //-109 <= target <= 109
    //只会存在一个有效答案
    //进阶：你可以想出一个时间复杂度小于 O(n2) 的算法吗？
    public static int[] twoSum(int[] nums, int target) {
        int [] indexs = new int[2];
        if(nums.length > 0 ){
            for (int i = 0; i < nums.length ; i++) {
                int is =  nums[i];
                for (int j = i+1; j < nums.length; j++) {
                    int js = nums[j];
                    if(is+js == target){
                        indexs[0] = i;
                        indexs[1] = j;
                    }
                }
            }
            System.out.println(indexs[0]+"+"+indexs[1]);
            return indexs;
        }else {
            return nums;
        }
    }

    public static int[] twoSum2(int[] nums, int target) {
        int[] indexs = new int[2];
        // 建立k-v ，一一对应的哈希表
        HashMap<Integer,Integer> hash = new HashMap<Integer,Integer>();
        for(int i = 0; i < nums.length; i++){
            if(hash.containsKey(nums[i])){
                indexs[0] = i;
                indexs[1] = hash.get(nums[i]);
                return indexs;
            }
            // 将数据存入 key为补数 ，value为下标
            hash.put(target-nums[i],i);
        }
        return indexs;
    }






}
